// $ANTLR 3.4 C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g 2013-02-27 11:51:07

  package practpl.doce;
  import java.util.Hashtable;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalizadorParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ASIGNA", "BLANCO", "COMA", "COMENTARIO", "COMPARA", "CORCHETEA", "CORCHETEC", "DIGITO", "DISTINTO", "DIV", "ENTERO", "IDENT", "IGUAL", "LETRA", "LLAVEA", "LLAVEC", "MAS", "MAYOR", "MAYORIGUAL", "MENOR", "MENORIGUAL", "MENOS", "MULT", "PARENTA", "PARENTC", "PUNTO", "REAL", "SEPARADOR", "TEXTO", "CALL", "FUNC", "INSTRS", "UNARIO"
    };

    public static final int EOF=-1;
    public static final int ASIGNA=4;
    public static final int BLANCO=5;
    public static final int COMA=6;
    public static final int COMENTARIO=7;
    public static final int COMPARA=8;
    public static final int CORCHETEA=9;
    public static final int CORCHETEC=10;
    public static final int DIGITO=11;
    public static final int DISTINTO=12;
    public static final int DIV=13;
    public static final int ENTERO=14;
    public static final int IDENT=15;
    public static final int IGUAL=16;
    public static final int LETRA=17;
    public static final int LLAVEA=18;
    public static final int LLAVEC=19;
    public static final int MAS=20;
    public static final int MAYOR=21;
    public static final int MAYORIGUAL=22;
    public static final int MENOR=23;
    public static final int MENORIGUAL=24;
    public static final int MENOS=25;
    public static final int MULT=26;
    public static final int PARENTA=27;
    public static final int PARENTC=28;
    public static final int PUNTO=29;
    public static final int REAL=30;
    public static final int SEPARADOR=31;
    public static final int TEXTO=32;
    public static final int CALL=33;
    public static final int FUNC=34;
    public static final int INSTRS=35;
    public static final int UNARIO=36;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public AnalizadorParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalizadorParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return AnalizadorParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g"; }


      List<CommonTree> functionDefinitions = new ArrayList<CommonTree>();


    public static class instrucciones_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "instrucciones"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:36:1: instrucciones : ( tipoentrada SEPARADOR )* EOF -> ^( INSTRS ( tipoentrada )* ) ;
    public final AnalizadorParser.instrucciones_return instrucciones() throws RecognitionException {
        AnalizadorParser.instrucciones_return retval = new AnalizadorParser.instrucciones_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token SEPARADOR2=null;
        Token EOF3=null;
        AnalizadorParser.tipoentrada_return tipoentrada1 =null;


        MiArbol SEPARADOR2_tree=null;
        MiArbol EOF3_tree=null;
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
        RewriteRuleTokenStream stream_SEPARADOR=new RewriteRuleTokenStream(adaptor,"token SEPARADOR");
        RewriteRuleSubtreeStream stream_tipoentrada=new RewriteRuleSubtreeStream(adaptor,"rule tipoentrada");
        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:37:3: ( ( tipoentrada SEPARADOR )* EOF -> ^( INSTRS ( tipoentrada )* ) )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:37:5: ( tipoentrada SEPARADOR )* EOF
            {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:37:5: ( tipoentrada SEPARADOR )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==CORCHETEA||(LA1_0 >= ENTERO && LA1_0 <= IDENT)||LA1_0==MENOS||LA1_0==PARENTA||LA1_0==REAL) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:37:6: tipoentrada SEPARADOR
            	    {
            	    pushFollow(FOLLOW_tipoentrada_in_instrucciones107);
            	    tipoentrada1=tipoentrada();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_tipoentrada.add(tipoentrada1.getTree());

            	    SEPARADOR2=(Token)match(input,SEPARADOR,FOLLOW_SEPARADOR_in_instrucciones109); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_SEPARADOR.add(SEPARADOR2);


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_instrucciones113); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_EOF.add(EOF3);


            // AST REWRITE
            // elements: tipoentrada
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (MiArbol)adaptor.nil();
            // 37:34: -> ^( INSTRS ( tipoentrada )* )
            {
                // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:37:37: ^( INSTRS ( tipoentrada )* )
                {
                MiArbol root_1 = (MiArbol)adaptor.nil();
                root_1 = (MiArbol)adaptor.becomeRoot(
                (MiArbol)adaptor.create(INSTRS, "INSTRS")
                , root_1);

                // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:37:46: ( tipoentrada )*
                while ( stream_tipoentrada.hasNext() ) {
                    adaptor.addChild(root_1, stream_tipoentrada.nextTree());

                }
                stream_tipoentrada.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "instrucciones"


    public static class tipoentrada_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "tipoentrada"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:40:1: tipoentrada : ( asignacion | expresion | funcion );
    public final AnalizadorParser.tipoentrada_return tipoentrada() throws RecognitionException {
        AnalizadorParser.tipoentrada_return retval = new AnalizadorParser.tipoentrada_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        AnalizadorParser.asignacion_return asignacion4 =null;

        AnalizadorParser.expresion_return expresion5 =null;

        AnalizadorParser.funcion_return funcion6 =null;



        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:41:3: ( asignacion | expresion | funcion )
            int alt2=3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==IDENT) ) {
                switch ( input.LA(2) ) {
                case IGUAL:
                    {
                    alt2=1;
                    }
                    break;
                case PARENTA:
                    {
                    int LA2_4 = input.LA(3);

                    if ( ((LA2_4 >= ENTERO && LA2_4 <= IDENT)||LA2_4==REAL) ) {
                        int LA2_5 = input.LA(4);

                        if ( (LA2_5==PARENTC) ) {
                            int LA2_6 = input.LA(5);

                            if ( (LA2_6==IGUAL) ) {
                                alt2=3;
                            }
                            else if ( (LA2_6==DIV||LA2_6==MAS||(LA2_6 >= MENOS && LA2_6 <= MULT)||LA2_6==SEPARADOR) ) {
                                alt2=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 2, 6, input);

                                throw nvae;

                            }
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 2, 5, input);

                            throw nvae;

                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 2, 4, input);

                        throw nvae;

                    }
                    }
                    break;
                case DIV:
                case MAS:
                case MENOS:
                case MULT:
                case SEPARADOR:
                    {
                    alt2=2;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae;

                }

            }
            else if ( (LA2_0==CORCHETEA||LA2_0==ENTERO||LA2_0==MENOS||LA2_0==PARENTA||LA2_0==REAL) ) {
                alt2=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;

            }
            switch (alt2) {
                case 1 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:41:5: asignacion
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_asignacion_in_tipoentrada135);
                    asignacion4=asignacion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, asignacion4.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:42:5: expresion
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_expresion_in_tipoentrada141);
                    expresion5=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion5.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:43:5: funcion
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_funcion_in_tipoentrada147);
                    funcion6=funcion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, funcion6.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "tipoentrada"


    public static class asignacion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "asignacion"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:46:1: asignacion : IDENT IGUAL ^ expresion ;
    public final AnalizadorParser.asignacion_return asignacion() throws RecognitionException {
        AnalizadorParser.asignacion_return retval = new AnalizadorParser.asignacion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT7=null;
        Token IGUAL8=null;
        AnalizadorParser.expresion_return expresion9 =null;


        MiArbol IDENT7_tree=null;
        MiArbol IGUAL8_tree=null;

        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:47:3: ( IDENT IGUAL ^ expresion )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:47:5: IDENT IGUAL ^ expresion
            {
            root_0 = (MiArbol)adaptor.nil();


            IDENT7=(Token)match(input,IDENT,FOLLOW_IDENT_in_asignacion161); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENT7_tree = 
            (MiArbol)adaptor.create(IDENT7)
            ;
            adaptor.addChild(root_0, IDENT7_tree);
            }

            IGUAL8=(Token)match(input,IGUAL,FOLLOW_IGUAL_in_asignacion163); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IGUAL8_tree = 
            (MiArbol)adaptor.create(IGUAL8)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(IGUAL8_tree, root_0);
            }

            pushFollow(FOLLOW_expresion_in_asignacion166);
            expresion9=expresion();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion9.getTree());

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "asignacion"


    public static class funcion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "funcion"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:50:1: funcion : IDENT PARENTA parametro PARENTC IGUAL expresion -> ^( FUNC IDENT parametro expresion ) ;
    public final AnalizadorParser.funcion_return funcion() throws RecognitionException {
        AnalizadorParser.funcion_return retval = new AnalizadorParser.funcion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT10=null;
        Token PARENTA11=null;
        Token PARENTC13=null;
        Token IGUAL14=null;
        AnalizadorParser.parametro_return parametro12 =null;

        AnalizadorParser.expresion_return expresion15 =null;


        MiArbol IDENT10_tree=null;
        MiArbol PARENTA11_tree=null;
        MiArbol PARENTC13_tree=null;
        MiArbol IGUAL14_tree=null;
        RewriteRuleTokenStream stream_PARENTC=new RewriteRuleTokenStream(adaptor,"token PARENTC");
        RewriteRuleTokenStream stream_IDENT=new RewriteRuleTokenStream(adaptor,"token IDENT");
        RewriteRuleTokenStream stream_IGUAL=new RewriteRuleTokenStream(adaptor,"token IGUAL");
        RewriteRuleTokenStream stream_PARENTA=new RewriteRuleTokenStream(adaptor,"token PARENTA");
        RewriteRuleSubtreeStream stream_parametro=new RewriteRuleSubtreeStream(adaptor,"rule parametro");
        RewriteRuleSubtreeStream stream_expresion=new RewriteRuleSubtreeStream(adaptor,"rule expresion");
        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:51:3: ( IDENT PARENTA parametro PARENTC IGUAL expresion -> ^( FUNC IDENT parametro expresion ) )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:51:5: IDENT PARENTA parametro PARENTC IGUAL expresion
            {
            IDENT10=(Token)match(input,IDENT,FOLLOW_IDENT_in_funcion179); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENT.add(IDENT10);


            PARENTA11=(Token)match(input,PARENTA,FOLLOW_PARENTA_in_funcion181); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_PARENTA.add(PARENTA11);


            pushFollow(FOLLOW_parametro_in_funcion183);
            parametro12=parametro();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_parametro.add(parametro12.getTree());

            PARENTC13=(Token)match(input,PARENTC,FOLLOW_PARENTC_in_funcion185); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_PARENTC.add(PARENTC13);


            IGUAL14=(Token)match(input,IGUAL,FOLLOW_IGUAL_in_funcion187); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IGUAL.add(IGUAL14);


            pushFollow(FOLLOW_expresion_in_funcion189);
            expresion15=expresion();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_expresion.add(expresion15.getTree());

            // AST REWRITE
            // elements: parametro, IDENT, expresion
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (MiArbol)adaptor.nil();
            // 51:53: -> ^( FUNC IDENT parametro expresion )
            {
                // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:51:56: ^( FUNC IDENT parametro expresion )
                {
                MiArbol root_1 = (MiArbol)adaptor.nil();
                root_1 = (MiArbol)adaptor.becomeRoot(
                (MiArbol)adaptor.create(FUNC, "FUNC")
                , root_1);

                adaptor.addChild(root_1, 
                stream_IDENT.nextNode()
                );

                adaptor.addChild(root_1, stream_parametro.nextTree());

                adaptor.addChild(root_1, stream_expresion.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving

                functionDefinitions.add(((MiArbol)retval.tree));
              
        }
        return retval;
    }
    // $ANTLR end "funcion"


    public static class numero_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "numero"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:57:1: numero : ( ENTERO | REAL );
    public final AnalizadorParser.numero_return numero() throws RecognitionException {
        AnalizadorParser.numero_return retval = new AnalizadorParser.numero_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token set16=null;

        MiArbol set16_tree=null;

        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:58:3: ( ENTERO | REAL )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:
            {
            root_0 = (MiArbol)adaptor.nil();


            set16=(Token)input.LT(1);

            if ( input.LA(1)==ENTERO||input.LA(1)==REAL ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (MiArbol)adaptor.create(set16)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "numero"


    public static class parametro_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "parametro"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:62:1: parametro : ( IDENT | ENTERO | REAL );
    public final AnalizadorParser.parametro_return parametro() throws RecognitionException {
        AnalizadorParser.parametro_return retval = new AnalizadorParser.parametro_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token set17=null;

        MiArbol set17_tree=null;

        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:63:3: ( IDENT | ENTERO | REAL )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:
            {
            root_0 = (MiArbol)adaptor.nil();


            set17=(Token)input.LT(1);

            if ( (input.LA(1) >= ENTERO && input.LA(1) <= IDENT)||input.LA(1)==REAL ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (MiArbol)adaptor.create(set17)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "parametro"


    public static class expresion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expresion"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:68:1: expresion : exp_mult ( ( MAS ^| MENOS ^) exp_mult )* ;
    public final AnalizadorParser.expresion_return expresion() throws RecognitionException {
        AnalizadorParser.expresion_return retval = new AnalizadorParser.expresion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MAS19=null;
        Token MENOS20=null;
        AnalizadorParser.exp_mult_return exp_mult18 =null;

        AnalizadorParser.exp_mult_return exp_mult21 =null;


        MiArbol MAS19_tree=null;
        MiArbol MENOS20_tree=null;

        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:3: ( exp_mult ( ( MAS ^| MENOS ^) exp_mult )* )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:5: exp_mult ( ( MAS ^| MENOS ^) exp_mult )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_exp_mult_in_expresion266);
            exp_mult18=exp_mult();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_mult18.getTree());

            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:14: ( ( MAS ^| MENOS ^) exp_mult )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==MAS||LA4_0==MENOS) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:15: ( MAS ^| MENOS ^) exp_mult
            	    {
            	    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:15: ( MAS ^| MENOS ^)
            	    int alt3=2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0==MAS) ) {
            	        alt3=1;
            	    }
            	    else if ( (LA3_0==MENOS) ) {
            	        alt3=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 3, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt3) {
            	        case 1 :
            	            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:16: MAS ^
            	            {
            	            MAS19=(Token)match(input,MAS,FOLLOW_MAS_in_expresion270); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MAS19_tree = 
            	            (MiArbol)adaptor.create(MAS19)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MAS19_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:69:21: MENOS ^
            	            {
            	            MENOS20=(Token)match(input,MENOS,FOLLOW_MENOS_in_expresion273); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MENOS20_tree = 
            	            (MiArbol)adaptor.create(MENOS20)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MENOS20_tree, root_0);
            	            }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_mult_in_expresion277);
            	    exp_mult21=exp_mult();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_mult21.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expresion"


    public static class exp_mult_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_mult"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:72:1: exp_mult : exp_base ( ( MULT ^| DIV ^) exp_base )* ;
    public final AnalizadorParser.exp_mult_return exp_mult() throws RecognitionException {
        AnalizadorParser.exp_mult_return retval = new AnalizadorParser.exp_mult_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MULT23=null;
        Token DIV24=null;
        AnalizadorParser.exp_base_return exp_base22 =null;

        AnalizadorParser.exp_base_return exp_base25 =null;


        MiArbol MULT23_tree=null;
        MiArbol DIV24_tree=null;

        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:3: ( exp_base ( ( MULT ^| DIV ^) exp_base )* )
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:5: exp_base ( ( MULT ^| DIV ^) exp_base )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_exp_base_in_exp_mult293);
            exp_base22=exp_base();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_base22.getTree());

            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:14: ( ( MULT ^| DIV ^) exp_base )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==DIV||LA6_0==MULT) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:15: ( MULT ^| DIV ^) exp_base
            	    {
            	    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:15: ( MULT ^| DIV ^)
            	    int alt5=2;
            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0==MULT) ) {
            	        alt5=1;
            	    }
            	    else if ( (LA5_0==DIV) ) {
            	        alt5=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 5, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt5) {
            	        case 1 :
            	            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:16: MULT ^
            	            {
            	            MULT23=(Token)match(input,MULT,FOLLOW_MULT_in_exp_mult297); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MULT23_tree = 
            	            (MiArbol)adaptor.create(MULT23)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MULT23_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:73:22: DIV ^
            	            {
            	            DIV24=(Token)match(input,DIV,FOLLOW_DIV_in_exp_mult300); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            DIV24_tree = 
            	            (MiArbol)adaptor.create(DIV24)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(DIV24_tree, root_0);
            	            }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_base_in_exp_mult304);
            	    exp_base25=exp_base();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_base25.getTree());

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_mult"


    public static class exp_base_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_base"
    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:76:1: exp_base : ( MENOS ^ numero | parametro | PARENTA ! expresion PARENTC !| CORCHETEA expresion CORCHETEC -> ^( UNARIO expresion ) | IDENT PARENTA parametro PARENTC -> ^( CALL IDENT parametro ) );
    public final AnalizadorParser.exp_base_return exp_base() throws RecognitionException {
        AnalizadorParser.exp_base_return retval = new AnalizadorParser.exp_base_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MENOS26=null;
        Token PARENTA29=null;
        Token PARENTC31=null;
        Token CORCHETEA32=null;
        Token CORCHETEC34=null;
        Token IDENT35=null;
        Token PARENTA36=null;
        Token PARENTC38=null;
        AnalizadorParser.numero_return numero27 =null;

        AnalizadorParser.parametro_return parametro28 =null;

        AnalizadorParser.expresion_return expresion30 =null;

        AnalizadorParser.expresion_return expresion33 =null;

        AnalizadorParser.parametro_return parametro37 =null;


        MiArbol MENOS26_tree=null;
        MiArbol PARENTA29_tree=null;
        MiArbol PARENTC31_tree=null;
        MiArbol CORCHETEA32_tree=null;
        MiArbol CORCHETEC34_tree=null;
        MiArbol IDENT35_tree=null;
        MiArbol PARENTA36_tree=null;
        MiArbol PARENTC38_tree=null;
        RewriteRuleTokenStream stream_PARENTC=new RewriteRuleTokenStream(adaptor,"token PARENTC");
        RewriteRuleTokenStream stream_IDENT=new RewriteRuleTokenStream(adaptor,"token IDENT");
        RewriteRuleTokenStream stream_CORCHETEC=new RewriteRuleTokenStream(adaptor,"token CORCHETEC");
        RewriteRuleTokenStream stream_CORCHETEA=new RewriteRuleTokenStream(adaptor,"token CORCHETEA");
        RewriteRuleTokenStream stream_PARENTA=new RewriteRuleTokenStream(adaptor,"token PARENTA");
        RewriteRuleSubtreeStream stream_parametro=new RewriteRuleSubtreeStream(adaptor,"rule parametro");
        RewriteRuleSubtreeStream stream_expresion=new RewriteRuleSubtreeStream(adaptor,"rule expresion");
        try {
            // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:77:3: ( MENOS ^ numero | parametro | PARENTA ! expresion PARENTC !| CORCHETEA expresion CORCHETEC -> ^( UNARIO expresion ) | IDENT PARENTA parametro PARENTC -> ^( CALL IDENT parametro ) )
            int alt7=5;
            switch ( input.LA(1) ) {
            case MENOS:
                {
                alt7=1;
                }
                break;
            case IDENT:
                {
                int LA7_2 = input.LA(2);

                if ( (LA7_2==PARENTA) ) {
                    alt7=5;
                }
                else if ( (LA7_2==EOF||LA7_2==CORCHETEC||LA7_2==DIV||LA7_2==MAS||(LA7_2 >= MENOS && LA7_2 <= MULT)||LA7_2==PARENTC||LA7_2==SEPARADOR) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 2, input);

                    throw nvae;

                }
                }
                break;
            case PARENTA:
                {
                alt7=3;
                }
                break;
            case CORCHETEA:
                {
                alt7=4;
                }
                break;
            case ENTERO:
            case REAL:
                {
                alt7=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:77:5: MENOS ^ numero
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    MENOS26=(Token)match(input,MENOS,FOLLOW_MENOS_in_exp_base320); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    MENOS26_tree = 
                    (MiArbol)adaptor.create(MENOS26)
                    ;
                    root_0 = (MiArbol)adaptor.becomeRoot(MENOS26_tree, root_0);
                    }

                    pushFollow(FOLLOW_numero_in_exp_base323);
                    numero27=numero();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, numero27.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:78:5: parametro
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_parametro_in_exp_base329);
                    parametro28=parametro();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parametro28.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:79:5: PARENTA ! expresion PARENTC !
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    PARENTA29=(Token)match(input,PARENTA,FOLLOW_PARENTA_in_exp_base335); if (state.failed) return retval;

                    pushFollow(FOLLOW_expresion_in_exp_base338);
                    expresion30=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion30.getTree());

                    PARENTC31=(Token)match(input,PARENTC,FOLLOW_PARENTC_in_exp_base340); if (state.failed) return retval;

                    }
                    break;
                case 4 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:80:5: CORCHETEA expresion CORCHETEC
                    {
                    CORCHETEA32=(Token)match(input,CORCHETEA,FOLLOW_CORCHETEA_in_exp_base347); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_CORCHETEA.add(CORCHETEA32);


                    pushFollow(FOLLOW_expresion_in_exp_base349);
                    expresion33=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expresion.add(expresion33.getTree());

                    CORCHETEC34=(Token)match(input,CORCHETEC,FOLLOW_CORCHETEC_in_exp_base351); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_CORCHETEC.add(CORCHETEC34);


                    // AST REWRITE
                    // elements: expresion
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (MiArbol)adaptor.nil();
                    // 80:35: -> ^( UNARIO expresion )
                    {
                        // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:80:38: ^( UNARIO expresion )
                        {
                        MiArbol root_1 = (MiArbol)adaptor.nil();
                        root_1 = (MiArbol)adaptor.becomeRoot(
                        (MiArbol)adaptor.create(UNARIO, "UNARIO")
                        , root_1);

                        adaptor.addChild(root_1, stream_expresion.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 5 :
                    // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:81:5: IDENT PARENTA parametro PARENTC
                    {
                    IDENT35=(Token)match(input,IDENT,FOLLOW_IDENT_in_exp_base366); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENT.add(IDENT35);


                    PARENTA36=(Token)match(input,PARENTA,FOLLOW_PARENTA_in_exp_base368); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_PARENTA.add(PARENTA36);


                    pushFollow(FOLLOW_parametro_in_exp_base370);
                    parametro37=parametro();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_parametro.add(parametro37.getTree());

                    PARENTC38=(Token)match(input,PARENTC,FOLLOW_PARENTC_in_exp_base372); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_PARENTC.add(PARENTC38);


                    // AST REWRITE
                    // elements: parametro, IDENT
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (MiArbol)adaptor.nil();
                    // 81:37: -> ^( CALL IDENT parametro )
                    {
                        // C:\\Users\\Elena\\workspace\\doce\\src\\practpl\\doce\\AnalizadorParser.g:81:40: ^( CALL IDENT parametro )
                        {
                        MiArbol root_1 = (MiArbol)adaptor.nil();
                        root_1 = (MiArbol)adaptor.becomeRoot(
                        (MiArbol)adaptor.create(CALL, "CALL")
                        , root_1);

                        adaptor.addChild(root_1, 
                        stream_IDENT.nextNode()
                        );

                        adaptor.addChild(root_1, stream_parametro.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }



        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_base"

    // Delegated rules


 

    public static final BitSet FOLLOW_tipoentrada_in_instrucciones107 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_instrucciones109 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_EOF_in_instrucciones113 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_asignacion_in_tipoentrada135 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expresion_in_tipoentrada141 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_funcion_in_tipoentrada147 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_asignacion161 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IGUAL_in_asignacion163 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_expresion_in_asignacion166 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_funcion179 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_PARENTA_in_funcion181 = new BitSet(new long[]{0x000000004000C000L});
    public static final BitSet FOLLOW_parametro_in_funcion183 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_PARENTC_in_funcion185 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IGUAL_in_funcion187 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_expresion_in_funcion189 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exp_mult_in_expresion266 = new BitSet(new long[]{0x0000000002100002L});
    public static final BitSet FOLLOW_MAS_in_expresion270 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_MENOS_in_expresion273 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_exp_mult_in_expresion277 = new BitSet(new long[]{0x0000000002100002L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult293 = new BitSet(new long[]{0x0000000004002002L});
    public static final BitSet FOLLOW_MULT_in_exp_mult297 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_DIV_in_exp_mult300 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult304 = new BitSet(new long[]{0x0000000004002002L});
    public static final BitSet FOLLOW_MENOS_in_exp_base320 = new BitSet(new long[]{0x0000000040004000L});
    public static final BitSet FOLLOW_numero_in_exp_base323 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parametro_in_exp_base329 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARENTA_in_exp_base335 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_expresion_in_exp_base338 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_PARENTC_in_exp_base340 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CORCHETEA_in_exp_base347 = new BitSet(new long[]{0x000000004A00C200L});
    public static final BitSet FOLLOW_expresion_in_exp_base349 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_CORCHETEC_in_exp_base351 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_exp_base366 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_PARENTA_in_exp_base368 = new BitSet(new long[]{0x000000004000C000L});
    public static final BitSet FOLLOW_parametro_in_exp_base370 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_PARENTC_in_exp_base372 = new BitSet(new long[]{0x0000000000000002L});

}